Section: New Results

Programming and Composition Models for Large-Scale Distributed Computing

Multi-active Objects

Participants : Ludovic Henrio, Fabrice Huet, Justine Rochas.

The active object programming model is particularly adapted to easily program distributed objects: it separates objects into several activities, each manipulated by a single thread, preventing data races. However, this programming model has its limitations in terms of expressiveness – risk of deadlocks – and of efficiency on multicore machines. We proposed to extend active objects with local multi-threading. We rely on declarative annotations for expressing potential concurrency between requests, allowing easy and high-level expression of concurrency. This year we realized the following:

• publication of the multiactive object programming model in COORDINATION 2013 [19]

• extension of the annotations to support the specification of:

  • thread management. This aims at specifying (i) thread reservation and (ii) thread limitation in order to control more finely the allocation of threads in a multiactive object.

  • priority of requests. The progammer can now specify a priority graph to have an influence on the order of execution of requests in a multiactive object

  This extension was initially explored in a master thesis [34] and led to a publication in SAC 2014 [21] .

• extensive use of multiactive objects in our CAN P2P network and implementation of usecases.

We plan to continue to improve the model, especially about compile-time checking of annotations and about fault tolerance of multiactive objects.

Algorithmic skeletons

Participant : Ludovic Henrio.

In the context of the SCADA associated team, we worked on the algorithmic skeleton programming model. The structured parallelism approach (skeletons) takes advantage of common patterns used in parallel and distributed applications. The skeleton paradigm separates concerns: the distribution aspect can be considered separately from the functional aspect of an application. In the previous year we designed the possibility for a skeleton to output events, which increases the control and monitoring capabilities. This year we achieved the following objectives:

• Encapsulation of the skandium skeleton runtime in a component in order to allow distributed execution of skeletons: local parallelism is handled by skandium while distributed execution is handled by the GCM component library.

• We applied the event framework for skeletons to design a framework allowing the skeleton execution to adapt autonomically in order to achieve a required qualiti of service. We have first promising results on this aspect and a publication has just been accepted to PMAM 2014.

Behavioural models for Distributed Components

Participants : Eric Madelaine, Nuno Gaspar, Oleksandra Kulankhina, Ludovic Henrio.

In the past [3] , we defined the behavioural semantics of active objects and components. This year we extended this work to address group communications. On the practical side, this work contributes to the Vercors platform; the overall picture being to provide tools to the programmer for defining his application, including its behavioural specification. Then some generic properties like absence of deadlocks, but also application specific properties, can be validated on the composed model using an existing model-checker. We mainly use the CADP model-checker, that also supports distributed generation of state-space. This year our main achievements are the following:

• We improved the specification of the behavioural model generation for component systems that we specified last year  [36] . A journal version is under submission.

• We extended the formal model of the GCM architecture and included the specification of the non-functional aspects.

• We worked on the design of a bisimulation equivalence relation adapted to pNets; such an equivalence relation would justify some of the verifications and simplifications we do in our verification platform. Bisimulation theory gives tools to prove the equivalent behaviour of two processes, but adapting it to the structural nature and to the parameterized definitions of pNets is a challenging task. We have obtained promising preliminary results on this aspect: we have a good library of examples illustrating the expressiveness of pNets and use it to study bisimulation techniques.

• We additionally have put considerable efforts on the improvement of the Vercors platform (see Section  5.2 ). We have totally updated the Vercors Components Editor. We have integrated the UML state machines editor from Obeo UML Designer (http://marketplace.obeonetwork.com/module/uml ) into Vercors platform. The integrated editor provides the tools for the specification of the components behavior.

• We have started implementing the behavioural semantics of [36] in the Vercors platform. This task consists in generating the behavior of GCM components in the form of pNets from the GCM architecture defined using VCE. This is an important task, involving intricate engineering issues, but also interesting research on methods for reducing the size of the generated models.

This work was done in collaboration with Rabéa Ameur-Boulifa from Télécom-Paristech and Min Zhang from ECNU Shanghai.

In parallel with core developments of the behavioural specification environment, we further collaborated with our industrial partners and enhanced our work around the use of proof assistants for our specification and verification purposes. In particular, this year:

• We made significant improvements on Mefresa, our Mechanized Framework for the Reasoning on Software Architectures. These were published in [17] . Moreover, we obtained preliminary results regarding its integration with GCM/ProActive, our java middleware for parallel and distributed programming.

• We specified, verified and implemented the HyperManager, a GCM distributed application for the management and monitoring of E-Connectware — a solution for the management of distributed RFID infrastructures. This work was published as an industrial case study in [18] .

Autonomic Monitoring and Management of Components

Participants : Françoise Baude, Bastien Sauvan.

We have completed the design of a framework for autonomic monitoring and management of component-based applications. We have provided an implementation using GCM/ProActive taking advantage of the possibility of adding components in the membrane. The framework for autonomic computing allows the designer to describe in a separate way each phase of the MAPE autonomic control loop (Monitoring, Analysis, Planning, and Execution), and to plug them or unplug them dynamically.

• This year, we worked on a journal paper presenting our implementation of GCM component model using active objects, and its use to provide autonomic components. The paper is under revision for SPE journal.

Optimization of data transfer in SOA and EDA models

Participants : Amjad Alshabani, Iyad Alshabani, Françoise Baude, Laurent Pellegrino, Bastien Sauvan, Quirino Zagareze.

Traditional client-server interactions rely upon method invocations with copy of the parameters. This can be useless in particular if the receiver does not effectively uses them. On the contrary, copying and transferring parameters lazily, and allowing the receiver to proceed without only some of them is a meaningful idea that we proved to be effective for active objects in the past [38] . This idea wasn't so far realized in the context of the web services technology, the most popular one used today for client-server SOAP-based interactions.

• We contributed to the offloading of objects representing parameters of the web service Java Apache CXF API [46] . It is innovative notably in the way the offloading of parameters for on-demand access can be delegated from services to services, which resembles the concept of first-class futures from ASP.

• Relying upon such an effective approach, we have applied a similar idea of “lazy copying and transfer” to the data parts of events in the context of event-driven architecture applications [26] . The middleware dynamically off-loads data (generally of huge size) attached to an event, according to some user-level policy expressed as annotation in the Java code at the subscriber side. The event itself, without its attachments, gets forwarded into the publish/subscribe brokering system (in our case, the EventCloud middleware, see Section 5.5 ) and its attachements are transferred to the subscriber on-demand. Compared to some existing propositions geared towards a data centric publish-subscribe pattern (e.g. the DDS OMG standard), ours is more user-friendly as it does not require the user code to explicitly program when to get the data attached to notified events. Also it features very low performance overhead, as additional experiments conducted show it: they are reported in an extended version of the SAC 2013 paper that is under minor revision for a special issue of the Science of Computer Programming journal.

Overall, this work opens the way towards a strong convergence between service oriented and event-driven technologies.

Multi-layer component architectures

Participant : Olivier Dalle.

Since a few years, we have been investigating the decomposition of a simulation application into multiple layers corresponding to the various concerns commonly found in a simulation: in addition to the various modeling domains that may be found in a single simulation application (e.g. telecommunications networks, road-networks, power-grids, and so on), a typical simulation includes various orthogonal concerns such as system modelling, simulation scenario, instrumentation and observation, distribution, and so on. This large number of concerns has put in light some limits of the traditional hierarchical component-based architectures and their associated ADL, as found in the FCM and GCM. In order order to cope with these limitations, we started a new component architecture model called Binding Layers centered on the binding rather than the component, with no hierarchy but advanced layering capabilities, and offering advanced support for dynamic structures. This project is composed of four levels of specification: the two first levels are ready for public realease, but some work is still needed for the development of the validation prototypes.